home *** CD-ROM | disk | FTP | other *** search
/ LG Super CD / LG Super CD.iso / bitpim / bitpim-0.62-setup.exe / {app} / bitpim.exe / unittest.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-11-06  |  27.3 KB  |  688 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.3)
  3.  
  4. __author__ = 'Steve Purcell'
  5. __email__ = 'stephen_purcell at yahoo dot com'
  6. __version__ = '#Revision: 1.46 $'[11:-2]
  7. import time
  8. import sys
  9. import traceback
  10. import string
  11. import os
  12. import types
  13. __all__ = [
  14.     'TestResult',
  15.     'TestCase',
  16.     'TestSuite',
  17.     'TextTestRunner',
  18.     'TestLoader',
  19.     'FunctionTestCase',
  20.     'main',
  21.     'defaultTestLoader']
  22. __all__.extend([
  23.     'getTestCaseNames',
  24.     'makeSuite',
  25.     'findTestCases'])
  26. __metaclass__ = type
  27.  
  28. def _strclass(cls):
  29.     return '%s.%s' % (cls.__module__, cls.__name__)
  30.  
  31.  
  32. class TestResult:
  33.     
  34.     def __init__(self):
  35.         self.failures = []
  36.         self.errors = []
  37.         self.testsRun = 0
  38.         self.shouldStop = 0
  39.  
  40.     
  41.     def startTest(self, test):
  42.         self.testsRun = self.testsRun + 1
  43.  
  44.     
  45.     def stopTest(self, test):
  46.         pass
  47.  
  48.     
  49.     def addError(self, test, err):
  50.         self.errors.append((test, self._exc_info_to_string(err)))
  51.  
  52.     
  53.     def addFailure(self, test, err):
  54.         self.failures.append((test, self._exc_info_to_string(err)))
  55.  
  56.     
  57.     def addSuccess(self, test):
  58.         pass
  59.  
  60.     
  61.     def wasSuccessful(self):
  62.         return None if len(self.errors) == len(self.errors) else len(self.errors) == 0
  63.  
  64.     
  65.     def stop(self):
  66.         self.shouldStop = 1
  67.  
  68.     
  69.     def _exc_info_to_string(self, err):
  70.         return string.join(traceback.format_exception(*err), '')
  71.  
  72.     
  73.     def __repr__(self):
  74.         return '<%s run=%i errors=%i failures=%i>' % (_strclass(self.__class__), self.testsRun, len(self.errors), len(self.failures))
  75.  
  76.  
  77.  
  78. class TestCase:
  79.     failureException = AssertionError
  80.     
  81.     def __init__(self, methodName = 'runTest'):
  82.         
  83.         try:
  84.             self._TestCase__testMethodName = methodName
  85.             testMethod = getattr(self, methodName)
  86.             self._TestCase__testMethodDoc = testMethod.__doc__
  87.         except AttributeError:
  88.             raise ValueError, 'no such test method in %s: %s' % (self.__class__, methodName)
  89.  
  90.  
  91.     
  92.     def setUp(self):
  93.         pass
  94.  
  95.     
  96.     def tearDown(self):
  97.         pass
  98.  
  99.     
  100.     def countTestCases(self):
  101.         return 1
  102.  
  103.     
  104.     def defaultTestResult(self):
  105.         return TestResult()
  106.  
  107.     
  108.     def shortDescription(self):
  109.         doc = self._TestCase__testMethodDoc
  110.         if not doc and string.strip(string.split(doc, '\n')[0]):
  111.             pass
  112.         return None
  113.  
  114.     
  115.     def id(self):
  116.         return '%s.%s' % (_strclass(self.__class__), self._TestCase__testMethodName)
  117.  
  118.     
  119.     def __str__(self):
  120.         return '%s (%s)' % (self._TestCase__testMethodName, _strclass(self.__class__))
  121.  
  122.     
  123.     def __repr__(self):
  124.         return '<%s testMethod=%s>' % (_strclass(self.__class__), self._TestCase__testMethodName)
  125.  
  126.     
  127.     def run(self, result = None):
  128.         return self(result)
  129.  
  130.     
  131.     def __call__(self, result = None):
  132.         if result is None:
  133.             result = self.defaultTestResult()
  134.         
  135.         result.startTest(self)
  136.         testMethod = getattr(self, self._TestCase__testMethodName)
  137.         
  138.         try:
  139.             self.setUp()
  140.         except KeyboardInterrupt:
  141.             raise 
  142.         except:
  143.             result.addError(self, self._TestCase__exc_info())
  144.             return None
  145.         
  146.  
  147.         ok = 0
  148.         
  149.         try:
  150.             testMethod()
  151.             ok = 1
  152.         except self.failureException:
  153.             result.addFailure(self, self._TestCase__exc_info())
  154.         except KeyboardInterrupt:
  155.             raise 
  156.         except:
  157.             result.addError(self, self._TestCase__exc_info())
  158.  
  159.         
  160.         try:
  161.             self.tearDown()
  162.         except KeyboardInterrupt:
  163.             raise 
  164.         except:
  165.             result.addError(self, self._TestCase__exc_info())
  166.             ok = 0
  167.  
  168.         if ok:
  169.             result.addSuccess(self)
  170.         result.stopTest(self)
  171.  
  172.     
  173.     def debug(self):
  174.         self.setUp()
  175.         getattr(self, self._TestCase__testMethodName)()
  176.         self.tearDown()
  177.  
  178.     
  179.     def __exc_info(self):
  180.         (exctype, excvalue, tb) = sys.exc_info()
  181.         if sys.platform[:4] == 'java':
  182.             return (exctype, excvalue, tb)
  183.         
  184.         newtb = tb.tb_next
  185.         if newtb is None:
  186.             return (exctype, excvalue, tb)
  187.         
  188.         return (exctype, excvalue, newtb)
  189.  
  190.     
  191.     def fail(self, msg = None):
  192.         raise self.failureException, msg
  193.  
  194.     
  195.     def failIf(self, expr, msg = None):
  196.         if expr:
  197.             raise self.failureException, msg
  198.         
  199.  
  200.     
  201.     def failUnless(self, expr, msg = None):
  202.         if not expr:
  203.             raise self.failureException, msg
  204.         
  205.  
  206.     
  207.     def failUnlessRaises(self, excClass, callableObj, *args, **kwargs):
  208.         
  209.         try:
  210.             callableObj(*args, **kwargs)
  211.         except excClass:
  212.             return None
  213.  
  214.         if hasattr(excClass, '__name__'):
  215.             excName = excClass.__name__
  216.         else:
  217.             excName = str(excClass)
  218.         raise self.failureException, excName
  219.  
  220.     
  221.     def failUnlessEqual(self, first, second, msg = None):
  222.         if not (first == second):
  223.             if not msg:
  224.                 pass
  225.             raise self.failureException, '%s != %s' % (`first`, `second`)
  226.         
  227.  
  228.     
  229.     def failIfEqual(self, first, second, msg = None):
  230.         if first == second:
  231.             if not msg:
  232.                 pass
  233.             raise self.failureException, '%s == %s' % (`first`, `second`)
  234.         
  235.  
  236.     
  237.     def failUnlessAlmostEqual(self, first, second, places = 7, msg = None):
  238.         if round(second - first, places) != 0:
  239.             if not msg:
  240.                 pass
  241.             raise self.failureException, '%s != %s within %s places' % (`first`, `second`, `places`)
  242.         
  243.  
  244.     
  245.     def failIfAlmostEqual(self, first, second, places = 7, msg = None):
  246.         if round(second - first, places) == 0:
  247.             if not msg:
  248.                 pass
  249.             raise self.failureException, '%s == %s within %s places' % (`first`, `second`, `places`)
  250.         
  251.  
  252.     assertEqual = assertEquals = failUnlessEqual
  253.     assertNotEqual = assertNotEquals = failIfEqual
  254.     assertAlmostEqual = assertAlmostEquals = failUnlessAlmostEqual
  255.     assertNotAlmostEqual = assertNotAlmostEquals = failIfAlmostEqual
  256.     assertRaises = failUnlessRaises
  257.     assert_ = failUnless
  258.  
  259.  
  260. class TestSuite:
  261.     
  262.     def __init__(self, tests = ()):
  263.         self._tests = []
  264.         self.addTests(tests)
  265.  
  266.     
  267.     def __repr__(self):
  268.         return '<%s tests=%s>' % (_strclass(self.__class__), self._tests)
  269.  
  270.     __str__ = __repr__
  271.     
  272.     def countTestCases(self):
  273.         cases = 0
  274.         for test in self._tests:
  275.             cases = cases + test.countTestCases()
  276.         
  277.         return cases
  278.  
  279.     
  280.     def addTest(self, test):
  281.         self._tests.append(test)
  282.  
  283.     
  284.     def addTests(self, tests):
  285.         for test in tests:
  286.             self.addTest(test)
  287.         
  288.  
  289.     
  290.     def run(self, result):
  291.         return self(result)
  292.  
  293.     
  294.     def __call__(self, result):
  295.         for test in self._tests:
  296.             if result.shouldStop:
  297.                 break
  298.             
  299.             test(result)
  300.         
  301.         return result
  302.  
  303.     
  304.     def debug(self):
  305.         for test in self._tests:
  306.             test.debug()
  307.         
  308.  
  309.  
  310.  
  311. class FunctionTestCase(TestCase):
  312.     
  313.     def __init__(self, testFunc, setUp = None, tearDown = None, description = None):
  314.         TestCase.__init__(self)
  315.         self._FunctionTestCase__setUpFunc = setUp
  316.         self._FunctionTestCase__tearDownFunc = tearDown
  317.         self._FunctionTestCase__testFunc = testFunc
  318.         self._FunctionTestCase__description = description
  319.  
  320.     
  321.     def setUp(self):
  322.         if self._FunctionTestCase__setUpFunc is not None:
  323.             self._FunctionTestCase__setUpFunc()
  324.         
  325.  
  326.     
  327.     def tearDown(self):
  328.         if self._FunctionTestCase__tearDownFunc is not None:
  329.             self._FunctionTestCase__tearDownFunc()
  330.         
  331.  
  332.     
  333.     def runTest(self):
  334.         self._FunctionTestCase__testFunc()
  335.  
  336.     
  337.     def id(self):
  338.         return self._FunctionTestCase__testFunc.__name__
  339.  
  340.     
  341.     def __str__(self):
  342.         return '%s (%s)' % (_strclass(self.__class__), self._FunctionTestCase__testFunc.__name__)
  343.  
  344.     
  345.     def __repr__(self):
  346.         return '<%s testFunc=%s>' % (_strclass(self.__class__), self._FunctionTestCase__testFunc)
  347.  
  348.     
  349.     def shortDescription(self):
  350.         if self._FunctionTestCase__description is not None:
  351.             return self._FunctionTestCase__description
  352.         
  353.         doc = self._FunctionTestCase__testFunc.__doc__
  354.         if not doc and string.strip(string.split(doc, '\n')[0]):
  355.             pass
  356.         return None
  357.  
  358.  
  359.  
  360. class TestLoader:
  361.     testMethodPrefix = 'test'
  362.     sortTestMethodsUsing = cmp
  363.     suiteClass = TestSuite
  364.     
  365.     def loadTestsFromTestCase(self, testCaseClass):
  366.         return self.suiteClass(map(testCaseClass, self.getTestCaseNames(testCaseClass)))
  367.  
  368.     
  369.     def loadTestsFromModule(self, module):
  370.         tests = []
  371.         for name in dir(module):
  372.             obj = getattr(module, name)
  373.             if isinstance(obj, (type, types.ClassType)) and issubclass(obj, TestCase):
  374.                 tests.append(self.loadTestsFromTestCase(obj))
  375.                 continue
  376.         
  377.         return self.suiteClass(tests)
  378.  
  379.     
  380.     def loadTestsFromName(self, name, module = None):
  381.         parts = string.split(name, '.')
  382.         if module is None:
  383.             if not parts:
  384.                 raise ValueError, 'incomplete test name: %s' % name
  385.             else:
  386.                 parts_copy = parts[:]
  387.                 while parts_copy:
  388.                     
  389.                     try:
  390.                         module = __import__(string.join(parts_copy, '.'))
  391.                     continue
  392.                     except ImportError:
  393.                         del parts_copy[-1]
  394.                         if not parts_copy:
  395.                             raise 
  396.                         
  397.                         not parts_copy
  398.                     
  399.  
  400.                     None<EXCEPTION MATCH>ImportError
  401.                 parts = parts[1:]
  402.         
  403.         obj = module
  404.         for part in parts:
  405.             obj = getattr(obj, part)
  406.         
  407.         import unittest
  408.         if type(obj) == types.ModuleType:
  409.             return self.loadTestsFromModule(obj)
  410.         elif isinstance(obj, (type, types.ClassType)) and issubclass(obj, unittest.TestCase):
  411.             return self.loadTestsFromTestCase(obj)
  412.         elif type(obj) == types.UnboundMethodType:
  413.             return obj.im_class(obj.__name__)
  414.         elif callable(obj):
  415.             test = obj()
  416.             if not isinstance(test, unittest.TestCase) and not isinstance(test, unittest.TestSuite):
  417.                 raise ValueError, 'calling %s returned %s, not a test' % (obj, test)
  418.             
  419.             return test
  420.         else:
  421.             raise ValueError, "don't know how to make test from: %s" % obj
  422.  
  423.     
  424.     def loadTestsFromNames(self, names, module = None):
  425.         suites = []
  426.         for name in names:
  427.             suites.append(self.loadTestsFromName(name, module))
  428.         
  429.         return self.suiteClass(suites)
  430.  
  431.     
  432.     def getTestCaseNames(self, testCaseClass):
  433.         testFnNames = filter((lambda n, p = self.testMethodPrefix: n[:len(p)] == p), dir(testCaseClass))
  434.         for baseclass in testCaseClass.__bases__:
  435.             for testFnName in self.getTestCaseNames(baseclass):
  436.                 if testFnName not in testFnNames:
  437.                     testFnNames.append(testFnName)
  438.                     continue
  439.             
  440.         
  441.         if self.sortTestMethodsUsing:
  442.             testFnNames.sort(self.sortTestMethodsUsing)
  443.         
  444.         return testFnNames
  445.  
  446.  
  447. defaultTestLoader = TestLoader()
  448.  
  449. def _makeLoader(prefix, sortUsing, suiteClass = None):
  450.     loader = TestLoader()
  451.     loader.sortTestMethodsUsing = sortUsing
  452.     loader.testMethodPrefix = prefix
  453.     if suiteClass:
  454.         loader.suiteClass = suiteClass
  455.     
  456.     return loader
  457.  
  458.  
  459. def getTestCaseNames(testCaseClass, prefix, sortUsing = cmp):
  460.     return _makeLoader(prefix, sortUsing).getTestCaseNames(testCaseClass)
  461.  
  462.  
  463. def makeSuite(testCaseClass, prefix = 'test', sortUsing = cmp, suiteClass = TestSuite):
  464.     return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromTestCase(testCaseClass)
  465.  
  466.  
  467. def findTestCases(module, prefix = 'test', sortUsing = cmp, suiteClass = TestSuite):
  468.     return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromModule(module)
  469.  
  470.  
  471. class _WritelnDecorator:
  472.     
  473.     def __init__(self, stream):
  474.         self.stream = stream
  475.  
  476.     
  477.     def __getattr__(self, attr):
  478.         return getattr(self.stream, attr)
  479.  
  480.     
  481.     def writeln(self, arg = None):
  482.         if arg:
  483.             self.write(arg)
  484.         
  485.         self.write('\n')
  486.  
  487.  
  488.  
  489. class _TextTestResult(TestResult):
  490.     separator1 = '=' * 70
  491.     separator2 = '-' * 70
  492.     
  493.     def __init__(self, stream, descriptions, verbosity):
  494.         TestResult.__init__(self)
  495.         self.stream = stream
  496.         self.showAll = verbosity > 1
  497.         self.dots = verbosity == 1
  498.         self.descriptions = descriptions
  499.  
  500.     
  501.     def getDescription(self, test):
  502.         if self.descriptions:
  503.             if not test.shortDescription():
  504.                 pass
  505.             return str(test)
  506.         else:
  507.             return str(test)
  508.  
  509.     
  510.     def startTest(self, test):
  511.         TestResult.startTest(self, test)
  512.         if self.showAll:
  513.             self.stream.write(self.getDescription(test))
  514.             self.stream.write(' ... ')
  515.         
  516.  
  517.     
  518.     def addSuccess(self, test):
  519.         TestResult.addSuccess(self, test)
  520.         if self.showAll:
  521.             self.stream.writeln('ok')
  522.         elif self.dots:
  523.             self.stream.write('.')
  524.         
  525.  
  526.     
  527.     def addError(self, test, err):
  528.         TestResult.addError(self, test, err)
  529.         if self.showAll:
  530.             self.stream.writeln('ERROR')
  531.         elif self.dots:
  532.             self.stream.write('E')
  533.         
  534.  
  535.     
  536.     def addFailure(self, test, err):
  537.         TestResult.addFailure(self, test, err)
  538.         if self.showAll:
  539.             self.stream.writeln('FAIL')
  540.         elif self.dots:
  541.             self.stream.write('F')
  542.         
  543.  
  544.     
  545.     def printErrors(self):
  546.         if self.dots or self.showAll:
  547.             self.stream.writeln()
  548.         
  549.         self.printErrorList('ERROR', self.errors)
  550.         self.printErrorList('FAIL', self.failures)
  551.  
  552.     
  553.     def printErrorList(self, flavour, errors):
  554.         for test, err in errors:
  555.             self.stream.writeln(self.separator1)
  556.             self.stream.writeln('%s: %s' % (flavour, self.getDescription(test)))
  557.             self.stream.writeln(self.separator2)
  558.             self.stream.writeln('%s' % err)
  559.         
  560.  
  561.  
  562.  
  563. class TextTestRunner:
  564.     
  565.     def __init__(self, stream = sys.stderr, descriptions = 1, verbosity = 1):
  566.         self.stream = _WritelnDecorator(stream)
  567.         self.descriptions = descriptions
  568.         self.verbosity = verbosity
  569.  
  570.     
  571.     def _makeResult(self):
  572.         return _TextTestResult(self.stream, self.descriptions, self.verbosity)
  573.  
  574.     
  575.     def run(self, test):
  576.         result = self._makeResult()
  577.         startTime = time.time()
  578.         test(result)
  579.         stopTime = time.time()
  580.         timeTaken = float(stopTime - startTime)
  581.         result.printErrors()
  582.         self.stream.writeln(result.separator2)
  583.         run = result.testsRun
  584.         if not run != 1 and 's':
  585.             pass
  586.         self.stream.writeln('Ran %d test%s in %.3fs' % (run, '', timeTaken))
  587.         self.stream.writeln()
  588.         if not result.wasSuccessful():
  589.             self.stream.write('FAILED (')
  590.             (failed, errored) = map(len, (result.failures, result.errors))
  591.             if failed:
  592.                 self.stream.write('failures=%d' % failed)
  593.             
  594.             if errored:
  595.                 if failed:
  596.                     self.stream.write(', ')
  597.                 
  598.                 self.stream.write('errors=%d' % errored)
  599.             
  600.             self.stream.writeln(')')
  601.         else:
  602.             self.stream.writeln('OK')
  603.         return result
  604.  
  605.  
  606.  
  607. class TestProgram:
  608.     USAGE = "Usage: %(progName)s [options] [test] [...]\n\nOptions:\n  -h, --help       Show this message\n  -v, --verbose    Verbose output\n  -q, --quiet      Minimal output\n\nExamples:\n  %(progName)s                               - run default set of tests\n  %(progName)s MyTestSuite                   - run suite 'MyTestSuite'\n  %(progName)s MyTestCase.testSomething      - run MyTestCase.testSomething\n  %(progName)s MyTestCase                    - run all 'test*' test methods\n                                               in MyTestCase\n"
  609.     
  610.     def __init__(self, module = '__main__', defaultTest = None, argv = None, testRunner = None, testLoader = defaultTestLoader):
  611.         if type(module) == type(''):
  612.             self.module = __import__(module)
  613.             for part in string.split(module, '.')[1:]:
  614.                 self.module = getattr(self.module, part)
  615.             
  616.         else:
  617.             self.module = module
  618.         if argv is None:
  619.             argv = sys.argv
  620.         
  621.         self.verbosity = 1
  622.         self.defaultTest = defaultTest
  623.         self.testRunner = testRunner
  624.         self.testLoader = testLoader
  625.         self.progName = os.path.basename(argv[0])
  626.         self.parseArgs(argv)
  627.         self.runTests()
  628.  
  629.     
  630.     def usageExit(self, msg = None):
  631.         if msg:
  632.             print msg
  633.         
  634.         print self.USAGE % self.__dict__
  635.         sys.exit(2)
  636.  
  637.     
  638.     def parseArgs(self, argv):
  639.         import getopt
  640.         
  641.         try:
  642.             (options, args) = getopt.getopt(argv[1:], 'hHvq', [
  643.                 'help',
  644.                 'verbose',
  645.                 'quiet'])
  646.             for opt, value in options:
  647.                 if opt in ('-h', '-H', '--help'):
  648.                     self.usageExit()
  649.                 
  650.                 if opt in ('-q', '--quiet'):
  651.                     self.verbosity = 0
  652.                 
  653.                 if opt in ('-v', '--verbose'):
  654.                     self.verbosity = 2
  655.                     continue
  656.             
  657.             if len(args) == 0 and self.defaultTest is None:
  658.                 self.test = self.testLoader.loadTestsFromModule(self.module)
  659.                 return None
  660.             
  661.             if len(args) > 0:
  662.                 self.testNames = args
  663.             else:
  664.                 self.testNames = (self.defaultTest,)
  665.             self.createTests()
  666.         except getopt.error:
  667.             msg = None
  668.             self.usageExit(msg)
  669.  
  670.  
  671.     
  672.     def createTests(self):
  673.         self.test = self.testLoader.loadTestsFromNames(self.testNames, self.module)
  674.  
  675.     
  676.     def runTests(self):
  677.         if self.testRunner is None:
  678.             self.testRunner = TextTestRunner(verbosity = self.verbosity)
  679.         
  680.         result = self.testRunner.run(self.test)
  681.         sys.exit(not result.wasSuccessful())
  682.  
  683.  
  684. main = TestProgram
  685. if __name__ == '__main__':
  686.     main(module = None)
  687.  
  688.